package Ecuations
{
	import Train.BaseTrain;
	
	import flash.display.DisplayObjectContainer;
	import flash.display.MovieClip;
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	
	public class MinTime
	{
		public static const USE_MIN_TIME:uint 	= 1;
		public static const USE_MAX_DERIVE:uint = 2;
		
		private static const BEFORE_HALF_VELOCITY:uint 	= 0;
		private static const AFTER_HALF_VELOCITY:uint 	= 1;
		private static const USING_PERCENTAGE:uint		= 2;
		
		private var _train:BaseTrain;
		private var _destStation:DistanceObject;
		private var _stopsInSegment:Boolean;
		private var _trainInitVelocityInSegment:Number = 0;
		private var _progresiveX:Number = 0;
		private var _passedHalfVelocity:Boolean = false;
		
		private var _stage:DisplayObjectContainer;
		
		private var _forcedSpeed:Number = 0;
		private var _trainSpeedWasForced:Boolean;
		
		private var _deltaTillHalfVelCalculated:Boolean = false;
		private var _deltaTillMaxVelCalculated:Boolean = false;
		
		private var _initVelocity:Number;
		private var _finalVelocity:Number;
		
		public var dataObjectList:Array;
		private var deltoToModifyPercentage:Number = 0;
		
		//variables necesarias para el calculo del delta agregado
		private var deltaWithPercentage:Boolean = false;
		private var addedPercentage:Number;
		private var minTimeDelta:Number;
		
		public function MinTime(train:BaseTrain, destination:DistanceObject, prevDestObj:DistanceObject, stage:DisplayObjectContainer, progresive:Number=0)
		{
			_train = train;
			_destStation = destination;
			_destStation.destPos = _destStation.destPos;
			_stage = stage;
			
			//_progresiveX = prevDestObj ? prevDestObj.initPos + prevDestObj.destPos : _destStation.initPos;
			_progresiveX = progresive;
			_stopsInSegment = _destStation.trainStops;
			_trainSpeedWasForced = false;
			
			dataObjectList = new Array();			
		}
		
		public function get finalVelocity():Number
		{
			return _finalVelocity;
		}

		public function set finalVelocity(value:Number):void
		{
			_finalVelocity = value;
		}

		public function get initVelocity():Number
		{
			return _initVelocity;
		}

		public function set initVelocity(value:Number):void
		{
			_initVelocity = value;
		}

		//el ultimo parametro seria el total de kilometros recorridos
		public function calculate(useAccel:uint, initV:Number, finalV:Number, finalPos:Number=0) : void
		{
			initVelocity = initV;
			finalVelocity = finalV;
			
			var accelToUse:Number;
			if (useAccel == USE_MIN_TIME)
			{
				accelToUse = _train.brakeAccel;
			}
			else
			{
				accelToUse = _train.deriveAccel;
			}
			
			/**
			 * Primero se fija que si la v del tren es mayor a la del segmento
			 * pone como velocidad a usar a la del segmento. Ya que no va poder ir mas rapido
			 * que la v del segmento
			 * **/
			if ( _train.trainVMax >= _destStation.segmentVMax )
			{
				_forcedSpeed = _destStation.segmentVMax;
				_trainSpeedWasForced = true;
			}
			
			/**
			 * Esto es porque si la velocidad con la que el tren comienza el recorrido 
			 * es igual a la de ese segmento que esta recorriendo, tiene que ir 
			 * directamente con constante hasta frenar, sin hacer ningun calculo previo
			 * **/
			if (initVelocity != _forcedSpeed || initVelocity != _train.trainVMax)
			{
			/**Este primer if es para saber si la v forzada por el segmento es
			 * mas chica que la vmax/2 del tren 
			 **/
			if (_forcedSpeed > 0 && _forcedSpeed <= _train.trainVMax/2)
			{
				if ( !_destStation.trainStops )
				{
					/**
					 * Si la velocidad final (o sea del segmento siguiente) es mayor
					 * a la velocidad q vengo
					 * **/
					if (finalVelocity >= _forcedSpeed)
					{
						//si yendo a la velocidad forzada me paso de la pos de destino
						if (getDeltaTillForcedSpeed() >= _destStation.destPos)
						{
							//calculo v en desPos y la seteo como la vfinal
							finalVelocity = getVelocityInDeltaX( _destStation.destPos, _train.accel );
							_progresiveX += _destStation.destPos;
							
							//TO DO: VER EL CASO DONDE TENGO QUE EMPEZAR A FRENAR DESDE EL SEGMENTO ANTERIOR
							
							//seteo la v final del segmento para que en el tramo siguiente, me la tome
							//como la v inicial
							_destStation.trainFinalVelocity = finalVelocity;
							
							createDataObj(finalVelocity, _train.accel, _progresiveX, getTimeMRUV(initVelocity, finalVelocity, _train.accel), _destStation.timeStopped );
							
							//salgo del metodo porque ya llegue a la destPos y tengo q pasar a evaluar el siguiente segmento
							return;
							
						}
						else //si llego hasta la vel forzada, tengo q seguir con v constante
						{
							//saco progresiva hasta forced speed 
							_progresiveX += getDeltaTillForcedSpeed();
							
							createDataObj(_forcedSpeed, _train.accel, _progresiveX, getTimeMRUV(initVelocity, _forcedSpeed, _train.accel), _destStation.timeStopped);
												
							//saco progresiva con v constante y grafico
							var prevPos:Number = _progresiveX;
							_progresiveX += getDeltaXWithConstantSpeed(true, false); //el primer booleano da igual si es true o false, aca no importa
							
							if (useAccel == USE_MIN_TIME)
								deltoToModifyPercentage = getDeltaXWithConstantSpeed(true, false);
							
							_destStation.trainFinalVelocity = _forcedSpeed;
							
							createDataObj(_forcedSpeed, 0, _progresiveX, getTimeMRU(prevPos, _progresiveX, _forcedSpeed ), _destStation.timeStopped );
							
							//salgo del metodo porque ya llegue a la destPos y tengo q pasar a evaluar el siguiente segmento
							return;
							//salgo del metodo
						}
					}
				}
				
				/**
				 * Se fija si el delta hasta la v forzada (acordate q estoy dentro del if q considera que force la v)
				 * mas lo que requeriria para frenar, se pasa del destino
				 * en ese caso, recalcula la velocidad para que pueda frenar bien
				 * **/
				//esto se sirve tambien para cuando el tren no frena y la v del proximo segmento es menor
				//ya que en vez de frenar en 0, frearia en una v menor a la forzada
				if (getDeltaTillForcedSpeed() + getDeltaXWhenBraking(accelToUse) >= _destStation.destPos)
				{
					_forcedSpeed = recalculateVelocity( BEFORE_HALF_VELOCITY, accelToUse, 0, 0, 0, finalPos );
					_trainSpeedWasForced = true;
				}
				/**
				 * Una vez q calculo la forzada, toma el delta hasta esa velocidad
				 * **/
				_progresiveX += getDeltaTillForcedSpeed();
				
				createDataObj(_forcedSpeed, _train.accel, _progresiveX, getTimeMRUV(initVelocity, _forcedSpeed, _train.accel), _destStation.timeStopped );
				
				_passedHalfVelocity = true;
			}
			/**
			 * Si llego a este punto es porque la velocidad del segmento es mayor a la vmax/2 del tren
			 * entonces puedo preguntar si el deltaX en la vmax/2 es mayor o igual que la pos de destino
			 * **/
			else if ( getDeltaXTilHalfVmax() >= _destStation.destPos  )
			{
				if ( !_destStation.trainStops )
				{
					/**
					 * Si entre aca, es porque me pase de la distancia y el tren no frena, entonces
					 * me fijo si la velocidad del siguiente secotr es mayor o igual para determinar
					 * q hacer
					 * **/
					if (finalVelocity >= getVelocityInDeltaX( _destStation.destPos, _train.accel ))
					{
						//calculo v en desPos y la sete como la vfinal
						finalVelocity = getVelocityInDeltaX( _destStation.destPos, _train.accel );
						_progresiveX += _destStation.destPos;
						createDataObj(finalVelocity, _train.accel, _progresiveX, getTimeMRUV(initVelocity, finalVelocity, _train.accel), _destStation.timeStopped );
						
						//seteo la v final del segmento para que en el tramo siguiente, me la tome
						//como la v inicial
						_destStation.trainFinalVelocity = finalVelocity;
						
						//salgo del metodo porque ya llegue a la destPos y tengo q pasar a evaluar el siguiente segmento
						return;
					}
				}
				
				/**
				 * Si llego aca es porque el tren frena y me estoy pasando de la dest pos
				 * entones recalculo la V para poder frenar
				 * **/
					_passedHalfVelocity = true;
					_forcedSpeed = recalculateVelocity( BEFORE_HALF_VELOCITY, accelToUse, 0, 0 , 0, finalPos );
					//si me llega a dar una v forzada mayor a la v del segmento, fuerzo la forzada para q sea
					//igual a la v del segmento (ESTO NI IDEA SI SUCEDE, ESTABA ACA JEJE.. SUPONGO Q LO PUSE POR ALGUNA RAZON :)
					if (_forcedSpeed >= _destStation.segmentVMax)
						_forcedSpeed = _destStation.segmentVMax;
					
					_trainSpeedWasForced = true;
					
					//Saco el delta hasta esa v forzada
					_progresiveX += getDeltaTillForcedSpeed();
					createDataObj(_forcedSpeed, _train.accel, _progresiveX, getTimeMRUV(initVelocity, _forcedSpeed, _train.accel), _destStation.timeStopped );
			}
			/**
			 * Si llego aca es que tomando tamb la dist de frenado, me paso de la pos de destino. Es decir, pude llegar 
			 * a la vmax/2, y o me pase llegando a la v max o desp de llegar a la vmax (cuando freno)
			 * **/
			else if ( getDeltaXTilHalfVmax() + getDeltaXTilVmax() + getDeltaXWhenBraking(accelToUse) > _destStation.destPos )
			{
				if ( !_destStation.trainStops )
				{
					/***
					 * Primero me fijo si la velocidad del proximo sector es mayor a  vmax/2, en ese caso
					 * primero hago q vaya hasta vmax/2 y despues lo hago ir hasta la velocidad del sector siguiente
					 * **/
					if (finalVelocity >= getVelocityInDeltaX( _destStation.destPos, _train.accel/2 ) )
					{
						_progresiveX += getDeltaXTilHalfVmax();
						//mc.graphics.lineTo( _progresiveX, _train.trainVMax/2);
						createDataObj(_train.trainVMax/2, _train.accel, _progresiveX, getTimeMRUV(initVelocity, _train.trainVMax/2, _train.accel), _destStation.timeStopped);
						
						_progresiveX += _destStation.destPos;
						finalVelocity = getVelocityInDeltaX( _destStation.destPos, _train.accel/2 );
						
						createDataObj(finalVelocity, _train.accel/2, _progresiveX, getTimeMRUV(_train.trainVMax/2, finalVelocity, _train.accel/2), _destStation.timeStopped);
						
						_destStation.trainFinalVelocity = finalVelocity;
						return;
					}
				}
				
				/**
				 * Aca entro si el tren frena, en ese caso, recalculo la velocidad.
				 * Esto tamb sirve para cuando no frena y la v del sector siguiente es menor
				 * a la q lleva el tren
				 * **/
				
				_forcedSpeed = recalculateVelocity( AFTER_HALF_VELOCITY, accelToUse, 0, 0, 0, finalPos );
				
				
				/**
				 * Si la velocidad forzada quedo por arriba de la vMax/2 (y obviamente por debajo de la vmax)
				 * **/
				if (_forcedSpeed >= _train.trainVMax/2)
				{
					_progresiveX += getDeltaXTilHalfVmax();
					//mc.graphics.lineTo( _progresiveX, _train.trainVMax/2);
					createDataObj(_train.trainVMax/2, _train.accel, _progresiveX, getTimeMRUV(initVelocity, _train.trainVMax/2, _train.accel), _destStation.timeStopped);
					
					_trainSpeedWasForced = true;
					
					/**
					 * Saco el delta hasta la v forzada.
					 * El metodo getDeltaXTillVMax sabe intermanete que si se forzo la velocidad, va a ir hasta
					 * la v forzada, sino va a ir hasta la maxima
					 * **/
					_progresiveX += getDeltaXTilVmax();
					//mc.graphics.lineTo( _progresiveX, _forcedSpeed );
					createDataObj(_forcedSpeed, _train.accel/2, _progresiveX, getTimeMRUV(_train.trainVMax/2, _forcedSpeed, _train.accel/2), _destStation.timeStopped );
					
					_deltaTillMaxVelCalculated = true;
					_deltaTillHalfVelCalculated = true;
				}
				/**
				 * Puede que la v forzada quede por debajo de la vmax/2, en ese caso, hago q vaya hasta ahi
				 * **/
				else
				{
					_trainSpeedWasForced = true;
					_progresiveX += getDeltaTillForcedSpeed();
					//mc.graphics.lineTo( _progresiveX, _forcedSpeed);
					createDataObj(_forcedSpeed, _train.accel, _progresiveX, getTimeMRUV(initVelocity, _forcedSpeed, _train.accel), _destStation.timeStopped);
				}
			}
			/**
			 * Si llega aca es xq pudo hacer todo el recorrido llegando a la v max y pudiendo frenar (hasta 0 o hasta la v 
			 * del sector siguiente
			 * **/
			else //llego a la v max del tren
			{
				/**
				 * este if es porque si arranco el sector con una v que es mayor a la mitad de la vmax/2, quiere
				 * decir que en un segmento anterior, ya supere la mitad de la v del tren, entonces no tengo que
				 * volver a calcular el delta hasta la vmax/2
				 *  **/
				if (initVelocity <= _train.trainVMax/2)
				{
					_progresiveX += getDeltaXTilHalfVmax();
					createDataObj(_train.trainVMax/2, _train.accel, _progresiveX, getTimeMRUV(initVelocity, _train.trainVMax/2, _train.accel), _destStation.timeStopped);
				}
				_progresiveX += getDeltaXTilVmax();
				//mc.graphics.lineTo( _progresiveX, _train.trainVMax );
				createDataObj( _trainSpeedWasForced ? _forcedSpeed : _train.trainVMax, _train.accel/2, _progresiveX, getTimeMRUV(_train.trainVMax/2, _train.trainVMax, _train.accel/2), _destStation.timeStopped);
				
				_deltaTillMaxVelCalculated = true;
				_deltaTillHalfVelCalculated = true;
					
				if ( !_destStation.trainStops )
				{
					//me fijo si la v del sector siguiente es mayor o igual a la q llevo
					//en ese caso, sigo con v constante
					var velToCheckWith:Number = _trainSpeedWasForced ? _forcedSpeed : _train.trainVMax;
					if (finalVelocity >= velToCheckWith )
					{
						//saco progresiva con v constante 
						var prevPos:Number = _progresiveX;
						_progresiveX += getDeltaXWithConstantSpeed(true, false); //el primer booleano da igual si es true o false, aca no importa
						
						if (useAccel == USE_MIN_TIME)
							deltoToModifyPercentage = getDeltaXWithConstantSpeed(true, false);
						
						_destStation.trainFinalVelocity = _trainSpeedWasForced ? _forcedSpeed : _train.trainVMax;
						createDataObj(_trainSpeedWasForced ? _forcedSpeed : _train.trainVMax, 0, _progresiveX, getTimeMRU(prevPos, _progresiveX, _trainSpeedWasForced ? _forcedSpeed : _train.trainVMax), _destStation.timeStopped );
						
						return;
					}
				}				
			}
			}
			
			/**
			 * En esta parte es donde se comienza a calcular los sectores con v constante y el frenado
			 * **/
			
			//la progresiva q tiene en v constante va a depender de q si estoy calculando con el porcentage o no
			var prevPos:Number = _progresiveX;
			if (deltaWithPercentage)
				var pepe:Number = alternativeDeltaX( getDeltaXWithConstantSpeed( useAccel == USE_MAX_DERIVE ), minTimeDelta );
			
			_progresiveX += deltaWithPercentage ? alternativeDeltaX( getDeltaXWithConstantSpeed( useAccel == USE_MAX_DERIVE ), minTimeDelta ) : getDeltaXWithConstantSpeed( useAccel == USE_MAX_DERIVE );
			
			
			//esta variable solo se setea si estoy calculando con tiempo minimo xq vendria a ser 
			//el delta en v constante q tengo q pasarle a la deriva para poder ir sacando un
			//porcentage
			if (useAccel == USE_MIN_TIME)
				deltoToModifyPercentage = getDeltaXWithConstantSpeed( useAccel == USE_MAX_DERIVE, _destStation.trainStops );
			
			//esto es para saber si crear el data obj. Porque si la distancia recorrida con V constante es 0, no hay necesidad de crear el data obj
			if (getDeltaXWithConstantSpeed( useAccel == USE_MAX_DERIVE, _destStation.trainStops ) != 0 || alternativeDeltaX( getDeltaXWithConstantSpeed( useAccel == USE_MAX_DERIVE ), minTimeDelta ) != 0)
			{
				createDataObj(_trainSpeedWasForced ? _forcedSpeed : _train.trainVMax, 0, _progresiveX, getTimeMRU(prevPos, _progresiveX, _trainSpeedWasForced ? _forcedSpeed : _train.trainVMax), _destStation.timeStopped );

			}
			
			/**
			 * Esto es para recalcular la velocidad intermedia entre lo que llevo con deriva y el frenado
			 * en teoria esto es para ir achicando la deriva
			 * Entnoces se fija que si esta activada la funcion de calcular con porcentage y la progresiva mas el delta de frenado
			 * con deriva se pasa del destino, entonces empieza a comer deriva para q no se pase
			 * **/
			if (deltaWithPercentage && _progresiveX + getDeltaXWhenBraking(accelToUse) > _destStation.destPos)
			{
				var middelVel:Number = recalculateVelocity(USING_PERCENTAGE, accelToUse, _trainSpeedWasForced ? _forcedSpeed : _train.trainVMax, finalVelocity, _progresiveX, finalPos );
				
				var currentVel:Number = _trainSpeedWasForced ? _forcedSpeed : _train.trainVMax;
				
				if (middelVel >= currentVel)
					middelVel = currentVel;
				
				/**
				 * Saca la progresiva con frenado con deriva hasta la velocidad calculada
				 * **/
				_progresiveX += getDeltaXWhenBraking(_train.deriveAccel, -1, middelVel);
				
				createDataObj(middelVel, _train.deriveAccel, _progresiveX, getTimeMRUV( _trainSpeedWasForced ? _forcedSpeed : _train.trainVMax, middelVel, _train.deriveAccel), _destStation.timeStopped );
				
				/**
				 * Desp saca la progresiva frenando
				 * **/
				_progresiveX += getDeltaXWhenBraking(_train.brakeAccel, middelVel, -1);
				createDataObj(finalVelocity, _train.brakeAccel, _progresiveX, getTimeMRUV( middelVel, finalVelocity, _train.brakeAccel), _destStation.timeStopped );
				
				
			}
			else
			{
				/**
				 * Este es el caso normal donde frena normalmente con deriva o con acel de frenado
				 * **/
				_progresiveX += getDeltaXWhenBraking(accelToUse);
				createDataObj(finalVelocity, accelToUse, _progresiveX, getTimeMRUV(_trainSpeedWasForced ? _forcedSpeed : _train.trainVMax, finalVelocity, accelToUse), _destStation.timeStopped );	
			}
		}
		
		//devuelve el deltaX para cuando me paso de la distancia antes de llegar a la vmax/2
		private function getDeltaTillForcedSpeed() : Number
		{
			return ( Math.pow(_forcedSpeed, 2) - Math.pow(initVelocity, 2) ) / (2*_train.accel);
		}
		
		
		//devuelve el deltaX hasta que llegua a la mitad de la velocidad del tren
		private function getDeltaXTilHalfVmax() : Number
		{
			return ( Math.pow(_train.trainVMax/2, 2) - Math.pow(initVelocity, 2) ) / (2*_train.accel);
		}
		
		//devuelve el deltaX desde que esta en Vmax/2 hasta que lleva a Vmax
		private function getDeltaXTilVmax() : Number
		{
			//separo en terminos la ecuacion para q no sea tan asqueroso el codigo!
			//ver hoja donde estan las ecuaciones para referencias!!!
			
			var speedToUse:Number;
			
			if (_trainSpeedWasForced)
				speedToUse = _forcedSpeed;
			else
				speedToUse = _train.trainVMax;
			
				
			if (_passedHalfVelocity)
			{
				return 0; //esto ni se si se usa ya jeje
			}
			else
			{
				var term1:Number = _train.accel * getDeltaXTilHalfVmax();
				var term2:Number = Math.pow(speedToUse , 2 );
				var term3:Number = Math.pow( _train.trainVMax/2, 2 );
			
				return (term1 + term2 - term3) / _train.accel;
			}
		}
		
		//devuelve el deltaX cuando esta frenando hasta llegar a la velocidad final
		//los ultimos 2 parametros son para el tema del porcentage nomas
		private function getDeltaXWhenBraking(accel:Number, initV:Number=-1, finalV:Number=-1) : Number
		{
			//esto para saber desde q velociad tiene q empezar a frenar
			//capaz q viene con v forzada o viene con v max, para eso esta el if
			var speedToUse:Number;
			if (_trainSpeedWasForced)
				speedToUse = _forcedSpeed;
			else
				speedToUse = _train.trainVMax;
			//devuelve vfinal al cuadrado - vinicial al cuadrado, todo sobre 2*aceleracion de deriva o frenado, depende la situacion
			return  ( Math.pow( finalV != -1 ? finalV : finalVelocity, 2) - Math.pow( initV != -1 ? initV : speedToUse, 2) ) / (2*accel);
		}
		
		//devuelve el deltaX cuando alcanza la vmax y se mantiene con esa v constante hasta q frene o pase de segmento
		private function getDeltaXWithConstantSpeed(useDerive:Boolean, breaks:Boolean=true) : Number
		{
			//estos terminos son para determinar que le tiene q restar a la posicion de destino
			//como para poder sacar la diferencia
			var term1:Number = _deltaTillHalfVelCalculated ? getDeltaXTilHalfVmax() : 0;
			var term2:Number = _deltaTillMaxVelCalculated ? getDeltaXTilVmax() : 0;
			var term3:Number = _trainSpeedWasForced ? getDeltaTillForcedSpeed() : 0;
			var accel:Number = useDerive ? _train.deriveAccel : _train.brakeAccel;
			var term4:Number = breaks ? getDeltaXWhenBraking(accel) : 0
			
			var distance:Number = _destStation.destPos - term1 - term2 - term3 - term4;
			
			if (distance < 0)
				return 0;
			else
				return distance;
			
		}
		
		//los ultimos 3 parametros son para el tema del porcentage nomas
		private function recalculateVelocity(condition:uint, accel:Number, initV:Number=0, finalV:Number=0, progresiveX:Number=0, destinPos:Number=0) : Number
		{
			var denom:Number;
			if (condition == BEFORE_HALF_VELOCITY)
			{
				var num:Number = _destStation.destPos + (Math.pow(initVelocity, 2) / (2*_train.accel)) - (Math.pow(finalVelocity, 2) / (2*accel)); 
				
				denom = (1/(2*_train.accel)) - (1/(2*accel));
				
				return Math.sqrt( ( num / denom ) );
			}
			else if (condition ==  AFTER_HALF_VELOCITY)
			{
				var num:Number = _destStation.destPos + (Math.pow(initVelocity, 2) / (2*_train.accel)) - (Math.pow(finalVelocity, 2) / (2*accel)); 
				
				denom = ( (1/_train.accel) - (1/(2*accel)) )
				
				return Math.sqrt( (num / denom) );
			}
			else if (condition == USING_PERCENTAGE)
			{
				var deltaX:Number = destinPos - progresiveX;
				
				var numerator:Number = deltaX + ( Math.pow(initV, 2) / (2*_train.deriveAccel) ) - ( Math.pow(finalV, 2) / (2*_train.brakeAccel) );
				
				denom = (1/(2*_train.deriveAccel)) - (1/(2*_train.brakeAccel));
				
				return Math.sqrt( numerator / denom );
			}
			
			return 0;
		}
		
		//esto es para sacar la velocidad en un determinado deltaX
		private function getVelocityInDeltaX(deltaX:Number, accel:Number) : Number
		{
			return Math.sqrt( (2*deltaX*accel) + Math.pow(initVelocity, 2 ) );
		}
		
		
		private function getTimeMRUV(initV:Number, finalV:Number, accel:Number) : Number
		{
			return (finalV - initV ) / accel;
		}
		
		private function getTimeMRU(initDeltaX:Number, finalDeltaX:Number, vel:Number) : Number
		{
			return (finalDeltaX - initDeltaX) / vel;
		}
		
		public function getSectorTotalTime() : Number
		{
			var totalTime:Number = 0;
			
			for (var i:int = 0; i < dataObjectList.length; i++)
			{
				totalTime += dataObjectList[i].time;
			}
			
			return totalTime;
		}
		
		/**
		 * Devuelve el delta al que va a haber que ir sumandole un porcentage
		 * **/
		public function getDeltaToModify() : Number
		{
			return deltoToModifyPercentage;
		}
		
		public function usePercentageChange(pValue:Number, mtDelta:Number) : void
		{
			deltaWithPercentage = true;
			addedPercentage = pValue;
			minTimeDelta = mtDelta;
		}
		
		//este es la formula magica q dio el prof para sacar el porcentage
		private function alternativeDeltaX(deriveDelta:Number, minTimeDelta:Number) : Number
		{
			if (deltaWithPercentage)
				return deriveDelta + ( ( addedPercentage * (minTimeDelta - deriveDelta) ) / 100 );
			else return 0
		}
		
		private function createDataObj(velocity:Number, accel:Number, deltaX:Number, time:Number, timeStopped:Number) : void
		{			
			var dataObj:DataObject = new DataObject();
			dataObj.velocity = velocity;
			dataObj.deltaX = deltaX;
			dataObj.accel = accel;
			dataObj.time = time;
			dataObj.timeStopped = timeStopped;
			
			dataObjectList.push(dataObj);
		}
	}
}